'use strict';

/*
 *  设备管理，巨龙_jHD23设备，已启用，字段合并到ipc
 */ 

const deviceModel = require('../models/device.model');
const httpUtil = require('../utils/http');
const Code = require('../common/error_code');

// 设备列表
async function device_list(ctx) {
    const devices = await deviceModel.find()
    ctx.success(Code.REQUEST_SUCCESS('请求成功'), devices);
}

// 手动新增设备
async function add_device(ctx){
    const params = ctx.request.body
    try{
        const deviceSchema = {
            // device_id:'设备id',
            device_ip: 'ip地址',
            device_uuid: 'uuid',
            // device_mac: 'mac地址',
            // device_code: '设备编号',
            // device_address: '设备地址',
            // device_status: '设备状态',
            // s_n: '序列号',
            // device_type: '设备类型',
            // channel_num: '通道数',
            // web_version: '页面版本',
            // core_version: '主程序版本',
            // version_date: '版本日期',
            // http_version: 'HTTP协议版本',
            // http_version_date: 'HTTP协议版本日期',
            // register_session: '注册Session',
            // alarm_switch: '报警开关',
            // black_alarm_switch: '黑名单报警开关',
            // white_alarm_switch: '白名单报警开关',
            // io_switch: 'IO输出',
            // io_type: 'io输入类型，1持续输出，2脉冲输出',
            // alarm_duration: '报警持续时间(s)',
            // io_status_type: 'IO输出状态类型，1常开，2常闭',
            // recognition_mode: '识别模式，1一直识别，2次数识别，3单张识别',
            // similarity_set: '比对相似度, 1~100',
            // alarm_start_time: '布防时间段',
            // alarm_end_time: '布防时间段',
            // subnet_mask: '子网掩码',
            // gateway: '网关',
            // preferred_dns: '首选DNS地址',
            // standby_dns: '备用DNS地址'
        }
        const schema = Object.keys(deviceSchema)
        if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请填写设备参数'))
        for(let key of schema){
            if(params[key]==undefined||params[key]===''){
                const msg = deviceSchema[key]
                return ctx.error(Code.REQUEST_ERROR(msg))
            }
        }
        const data = await deviceModel.findOne({device_uuid:params.device_uuid})
        if(data){
            return ctx.error(Code.REQUEST_ERROR('设备UUID重复'))
        }
        const newDevice = new deviceModel(params)
        await newDevice.save()
        ctx.success(Code.REQUEST_SUCCESS('添加成功'))
    }catch(err){
        console.log(err)
        let message = err && err.message
        let msg, others = []
        if(message) {
           [ msg,...others ] = message.split(': ').reverse()
        }
        ctx.error(Code.REQUEST_ERROR(msg||'添加失败'))
    }
}

// 删除设备
async function delete_device(ctx){
    const params = ctx.request.body
    try{
        if(!params || typeof params !=='object' || !params.device_uuid) return ctx.error(Code.REQUEST_ERROR('请选择要删除的设备'))
        const data = await deviceModel.findOneAndRemove({device_uuid:params.device_uuid})
        if(data){
            return ctx.success(Code.REQUEST_SUCCESS('删除成功'))
        }
        return ctx.error(Code.REQUEST_ERROR('未找到对应的设备'))
    }catch(err){
        return ctx.error(Code.REQUEST_ERROR('更新失败'))
    }
}

// 报警设置
async function update_alarm(ctx){
    const params = ctx.request.body
    try{
        const alarmParams = {
            device_uuid:'uuid',
            alarm_switch: '报警开关',
            black_alarm_switch: '黑名单报警开关',
            white_alarm_switch: '白名单报警开关',
            io_switch: 'IO输出',
            io_type: 'io输入类型，1持续输出，2脉冲输出',
            alarm_duration: '报警持续时间(s)',
            io_status_type: 'IO输出状态类型，1常开，2常闭',
            recognition_mode: '识别模式，1一直识别，2次数识别，3单张识别',
            similarity_set: '比对相似度, 1~100',
            alarm_start_time: '布防时间段',
            alarm_end_time: '布防时间段',
        }
        const schema = Object.keys(alarmParams)
        if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请填写设备参数'))
        for(let key of schema){
            if(params[key]==undefined||params[key]===''){
                const msg = alarmParams[key]
                return ctx.error(Code.REQUEST_ERROR(msg))
            }
        }
        const rangeRegex = /\d{2}:\d{2}/
        if(!rangeRegex.test(params.alarm_start_time)||!rangeRegex.test(params.alarm_end_time)){
            return ctx.error(Code.REQUEST_ERROR('布防时间段时间格式错误'))
        }
        const data = await deviceModel.findOneAndUpdate({device_uuid:params.device_uuid},params)
        if(data){
            return ctx.success(Code.REQUEST_SUCCESS('更新成功'))
        }
        return ctx.error(Code.REQUEST_ERROR('未找到对应的设备'))
    }catch(err){
        console.log(err)
        return ctx.error(Code.REQUEST_ERROR('更新失败'))
    }
}


// 网络设置
async function update_net(ctx){
    const params = ctx.request.body
    try{
        const netParams = {
            device_uuid:'uuid',
            subnet_mask: '子网掩码',
            gateway: '网关',
            preferred_dns: '首选DNS地址',
            standby_dns: '备用DNS地址'
        }
        const schema = Object.keys(netParams)
        if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请填写设备参数'))
        for(let key of schema){
            if(params[key]==undefined||params[key]===''){
                const msg = netParams[key]
                return ctx.error(Code.REQUEST_ERROR(msg))
            }
        }
        const ipRegex = /\d{3}\.\d{3}\.\d{1,3}\.\d{1,3}/
        if(!ipRegex.test(params.device_ip)) return ctx.error(Code.REQUEST_ERROR('ip地址格式不规范'))
        const data = await deviceModel.findOneAndUpdate({device_uuid:params.device_uuid},params)
        if(data){
            return ctx.success(Code.REQUEST_SUCCESS('更新成功'))
        }
        return ctx.error(Code.REQUEST_ERROR('未找到对应的设备'))
    }catch(err){
        console.log(err)
        return ctx.error(Code.REQUEST_ERROR('更新失败'))
    }
}

// 重启设备
async function restart_device(ctx){
    const isDev = ctx.request.host.indexOf('localhost')>-1
    const params = ctx.request.body
    try{
        const deviceParams = {
            ip:'设备ip不能为空',
            UUID:'uuid',
            Session: '注册session',
        }
        const schema = Object.keys(deviceParams)
        if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请填写设备参数'))
        for(let key of schema){
            if(params[key]==undefined||params[key]===''){
                const msg = deviceParams[key]
                return ctx.error(Code.REQUEST_ERROR(msg))
            }
        }
        params.Name = 'restartRequest'
        params.TimeStamp = Math.floor(+new Date()/1000)
        const ipRegex = /\d{3}\.\d{3}\.\d{1,3}\.\d{1,3}/
        if(!ipRegex.test(params.ip)) return ctx.error(Code.REQUEST_ERROR('ip地址格式不规范'))
        const data = await deviceModel.findOneAndUpdate({device_uuid:params.UUID},{device_status:2})
        if(data){
            try{
                const res = await httpUtil.post(`http://${isDev?params.ip:'127.0.0.1'}:8011/Request`,params)
                if(res && res.Code === 1) {
                    return ctx.success(Code.REQUEST_SUCCESS('操作成功，即将重启'))
                }else{
                    await deviceModel.findOneAndUpdate({device_uuid:params.UUID},{device_status:3})
                    return ctx.error(Code.REQUEST_ERROR('重启失败，请检查设备连接是否正常'))
                }
            }catch(err){
                await deviceModel.findOneAndUpdate({device_uuid:params.UUID},{device_status:3})
                return ctx.error(Code.REQUEST_ERROR('重启失败'))
            }
        }
        return ctx.error(Code.REQUEST_ERROR('未找到对应的设备'))
    }catch(err){
        return ctx.error(Code.REQUEST_ERROR('操作失败'))
    }
}
exports.device_list = device_list
exports.add_device = add_device
exports.delete_device = delete_device
exports.update_alarm = update_alarm
exports.update_net = update_net
exports.restart_device = restart_device